// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.purchase.rgoods.order;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.PurchaseRgoodsOrder;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(PurchaseRgoodsOrder.class)
@Setter
@Getter
public class PurchaseRgoodsOrderSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "PurchaseRgoodsOrder".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("wid", "w");
    map.put("creatorUser", "su");
    map.put("supplierId", "s");
    map.put("buyerUid", "su2");
    map.put("dept", "sd");
    map.put("sid", "si");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();
    map.put(
      "products.productId",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN purchase_rgoods_order_product AS RO_1 ON RO_1.del_flag = 0 AND RO_1.parent_id = t.id"
        )
        .setTableAlias("RO_1")
        .setColumnName("product_id")
        .setNeedGroupBy(true)
    );
    map.put(
      "products.productSku",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN purchase_rgoods_order_product AS RO_2 ON RO_2.del_flag = 0 AND RO_2.parent_id = t.id"
        )
        .setTableAlias("RO_2")
        .setColumnName("product_sku")
        .setNeedGroupBy(true)
    );
    map.put(
      "products.fnsku",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN purchase_rgoods_order_product AS RO_3 ON RO_3.del_flag = 0 AND RO_3.parent_id = t.id"
        )
        .setTableAlias("RO_3")
        .setColumnName("fnsku")
        .setNeedGroupBy(true)
    );
    map.put(
      "products.productId.name",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN product AS RO_4 ON RO_4.del_flag = 0 AND RO_4.id = RO_1.product_id"
        )
        .setTableAlias("RO_4")
        .setColumnName("name")
        .setDepends(Collections.singletonList("products.productId"))
    );
    map.put(
      "products.productId.spu",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN product AS RO_5 ON RO_5.del_flag = 0 AND RO_5.id = RO_1.product_id"
        )
        .setTableAlias("RO_5")
        .setColumnName("spu")
        .setDepends(Collections.singletonList("products.productId"))
    );
    map.put(
      "products.productId.spuName",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN product AS RO_6 ON RO_6.del_flag = 0 AND RO_6.id = RO_1.product_id"
        )
        .setTableAlias("RO_6")
        .setColumnName("spu_name")
        .setDepends(Collections.singletonList("products.productId"))
    );

    return map;
  }

  private Long products_productId;
  private List<String> products_productIdInList;
  private String products_productSku;
  private List<String> products_productSkuInList;
  private Long products_fnsku;
  private List<String> products_fnskuInList;
  private String products_productId_name;
  private List<String> products_productId_nameInList;
  private String products_productId_spu;
  private List<String> products_productId_spuInList;
  private String products_productId_spuName;
  private List<String> products_productId_spuNameInList;

  /**
   * 指定使用特定的视图过滤条件
   * <p>
   * 有效值包括：PurchaseRgoodsOrder/AllRetrunOrder, PurchaseRgoodsOrder/PendingApproval, PurchaseRgoodsOrder/OrderProcessed, PurchaseRgoodsOrder/OrderVoided
   * </p>
   */
  private String byViewName;

  /**
   * 采购仓库
   */
  private Long wid;

  /**
   * 采购仓库 比较(eq)
   */
  private Long widEq;
  /**
   * 采购仓库 比较(neq)
   */
  private Long widNeq;
  /**
   * 采购仓库 比较(gt)
   */
  private Long widGt;
  /**
   * 采购仓库 比较(gte)
   */
  private Long widGte;
  /**
   * 采购仓库 比较(lt)
   */
  private Long widLt;
  /**
   * 采购仓库 比较(lte)
   */
  private Long widLte;
  /**
   * 采购仓库 比较(contains)
   */
  private Long widContains;
  /**
   * 采购仓库 比较(notcontains)
   */
  private Long widNotcontains;
  /**
   * 采购仓库 比较(startswith)
   */
  private Long widStartswith;
  /**
   * 采购仓库 比较(endswith)
   */
  private Long widEndswith;
  /**
   * 采购仓库 比较(isnull)
   */
  private Boolean widIsnull;
  /**
   * 采购仓库 比较(isnotnull)
   */
  private Boolean widIsnotnull;
  /**
   * 采购仓库的仓库名称 比较(eq)
   */
  private String widNameEq;
  /**
   * 采购仓库的仓库名称 比较(neq)
   */
  private String widNameNeq;
  /**
   * 采购仓库的仓库名称 比较(gt)
   */
  private String widNameGt;
  /**
   * 采购仓库的仓库名称 比较(gte)
   */
  private String widNameGte;
  /**
   * 采购仓库的仓库名称 比较(lt)
   */
  private String widNameLt;
  /**
   * 采购仓库的仓库名称 比较(lte)
   */
  private String widNameLte;
  /**
   * 采购仓库的仓库名称 比较(contains)
   */
  private String widNameContains;
  /**
   * 采购仓库的仓库名称 比较(notcontains)
   */
  private String widNameNotcontains;
  /**
   * 采购仓库的仓库名称 比较(startswith)
   */
  private String widNameStartswith;
  /**
   * 采购仓库的仓库名称 比较(endswith)
   */
  private String widNameEndswith;
  /**
   * 采购仓库的仓库名称 比较(isnull)
   */
  private Boolean widNameIsnull;
  /**
   * 采购仓库的仓库名称 比较(isnotnull)
   */
  private Boolean widNameIsnotnull;

  /**
   * 采购仓库(范围搜索)
   */
  private List<Long> widInList;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 退货单号(模糊搜索)
   */
  private String orderNo;

  /**
   * 退货单号 比较(eq)
   */
  private String orderNoEq;
  /**
   * 退货单号 比较(neq)
   */
  private String orderNoNeq;
  /**
   * 退货单号 比较(gt)
   */
  private String orderNoGt;
  /**
   * 退货单号 比较(gte)
   */
  private String orderNoGte;
  /**
   * 退货单号 比较(lt)
   */
  private String orderNoLt;
  /**
   * 退货单号 比较(lte)
   */
  private String orderNoLte;
  /**
   * 退货单号 比较(contains)
   */
  private String orderNoContains;
  /**
   * 退货单号 比较(notcontains)
   */
  private String orderNoNotcontains;
  /**
   * 退货单号 比较(startswith)
   */
  private String orderNoStartswith;
  /**
   * 退货单号 比较(endswith)
   */
  private String orderNoEndswith;
  /**
   * 退货单号 比较(isnull)
   */
  private Boolean orderNoIsnull;
  /**
   * 退货单号 比较(isnotnull)
   */
  private Boolean orderNoIsnotnull;

  /**
   * 退货单号(精确搜索)
   */
  private List<String> orderNoInList;

  /**
   * 创建人
   */
  private Long creatorUser;

  /**
   * 创建人 比较(eq)
   */
  private Long creatorUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long creatorUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long creatorUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long creatorUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long creatorUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long creatorUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long creatorUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long creatorUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long creatorUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long creatorUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean creatorUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean creatorUserIsnotnull;
  /**
   * 创建人的显示用户名 比较(eq)
   */
  private String creatorUserNameEq;
  /**
   * 创建人的显示用户名 比较(neq)
   */
  private String creatorUserNameNeq;
  /**
   * 创建人的显示用户名 比较(gt)
   */
  private String creatorUserNameGt;
  /**
   * 创建人的显示用户名 比较(gte)
   */
  private String creatorUserNameGte;
  /**
   * 创建人的显示用户名 比较(lt)
   */
  private String creatorUserNameLt;
  /**
   * 创建人的显示用户名 比较(lte)
   */
  private String creatorUserNameLte;
  /**
   * 创建人的显示用户名 比较(contains)
   */
  private String creatorUserNameContains;
  /**
   * 创建人的显示用户名 比较(notcontains)
   */
  private String creatorUserNameNotcontains;
  /**
   * 创建人的显示用户名 比较(startswith)
   */
  private String creatorUserNameStartswith;
  /**
   * 创建人的显示用户名 比较(endswith)
   */
  private String creatorUserNameEndswith;
  /**
   * 创建人的显示用户名 比较(isnull)
   */
  private Boolean creatorUserNameIsnull;
  /**
   * 创建人的显示用户名 比较(isnotnull)
   */
  private Boolean creatorUserNameIsnotnull;

  /**
   * 创建人(范围搜索)
   */
  private List<Long> creatorUserInList;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date creatorTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date creatorTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date creatorTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date creatorTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date creatorTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date creatorTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date creatorTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date creatorTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date creatorTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date creatorTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date creatorTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date creatorTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean creatorTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean creatorTimeIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 供应商
   */
  private Long supplierId;

  /**
   * 供应商 比较(eq)
   */
  private Long supplierIdEq;
  /**
   * 供应商 比较(neq)
   */
  private Long supplierIdNeq;
  /**
   * 供应商 比较(gt)
   */
  private Long supplierIdGt;
  /**
   * 供应商 比较(gte)
   */
  private Long supplierIdGte;
  /**
   * 供应商 比较(lt)
   */
  private Long supplierIdLt;
  /**
   * 供应商 比较(lte)
   */
  private Long supplierIdLte;
  /**
   * 供应商 比较(contains)
   */
  private Long supplierIdContains;
  /**
   * 供应商 比较(notcontains)
   */
  private Long supplierIdNotcontains;
  /**
   * 供应商 比较(startswith)
   */
  private Long supplierIdStartswith;
  /**
   * 供应商 比较(endswith)
   */
  private Long supplierIdEndswith;
  /**
   * 供应商 比较(isnull)
   */
  private Boolean supplierIdIsnull;
  /**
   * 供应商 比较(isnotnull)
   */
  private Boolean supplierIdIsnotnull;
  /**
   * 供应商的供应商简称 比较(eq)
   */
  private String supplierIdSupplierNameEq;
  /**
   * 供应商的供应商简称 比较(neq)
   */
  private String supplierIdSupplierNameNeq;
  /**
   * 供应商的供应商简称 比较(gt)
   */
  private String supplierIdSupplierNameGt;
  /**
   * 供应商的供应商简称 比较(gte)
   */
  private String supplierIdSupplierNameGte;
  /**
   * 供应商的供应商简称 比较(lt)
   */
  private String supplierIdSupplierNameLt;
  /**
   * 供应商的供应商简称 比较(lte)
   */
  private String supplierIdSupplierNameLte;
  /**
   * 供应商的供应商简称 比较(contains)
   */
  private String supplierIdSupplierNameContains;
  /**
   * 供应商的供应商简称 比较(notcontains)
   */
  private String supplierIdSupplierNameNotcontains;
  /**
   * 供应商的供应商简称 比较(startswith)
   */
  private String supplierIdSupplierNameStartswith;
  /**
   * 供应商的供应商简称 比较(endswith)
   */
  private String supplierIdSupplierNameEndswith;
  /**
   * 供应商的供应商简称 比较(isnull)
   */
  private Boolean supplierIdSupplierNameIsnull;
  /**
   * 供应商的供应商简称 比较(isnotnull)
   */
  private Boolean supplierIdSupplierNameIsnotnull;

  /**
   * 供应商(范围搜索)
   */
  private List<Long> supplierIdInList;

  /**
   * 采购单号(模糊搜索)
   */
  private String purchaseOrderCode;

  /**
   * 采购单号 比较(eq)
   */
  private String purchaseOrderCodeEq;
  /**
   * 采购单号 比较(neq)
   */
  private String purchaseOrderCodeNeq;
  /**
   * 采购单号 比较(gt)
   */
  private String purchaseOrderCodeGt;
  /**
   * 采购单号 比较(gte)
   */
  private String purchaseOrderCodeGte;
  /**
   * 采购单号 比较(lt)
   */
  private String purchaseOrderCodeLt;
  /**
   * 采购单号 比较(lte)
   */
  private String purchaseOrderCodeLte;
  /**
   * 采购单号 比较(contains)
   */
  private String purchaseOrderCodeContains;
  /**
   * 采购单号 比较(notcontains)
   */
  private String purchaseOrderCodeNotcontains;
  /**
   * 采购单号 比较(startswith)
   */
  private String purchaseOrderCodeStartswith;
  /**
   * 采购单号 比较(endswith)
   */
  private String purchaseOrderCodeEndswith;
  /**
   * 采购单号 比较(isnull)
   */
  private Boolean purchaseOrderCodeIsnull;
  /**
   * 采购单号 比较(isnotnull)
   */
  private Boolean purchaseOrderCodeIsnotnull;

  /**
   * 采购单号(精确搜索)
   */
  private List<String> purchaseOrderCodeInList;

  /**
   * 币种
   */
  private String purchaseCurrency;

  /**
   * 币种 比较(eq)
   */
  private String purchaseCurrencyEq;
  /**
   * 币种 比较(neq)
   */
  private String purchaseCurrencyNeq;
  /**
   * 币种 比较(gt)
   */
  private String purchaseCurrencyGt;
  /**
   * 币种 比较(gte)
   */
  private String purchaseCurrencyGte;
  /**
   * 币种 比较(lt)
   */
  private String purchaseCurrencyLt;
  /**
   * 币种 比较(lte)
   */
  private String purchaseCurrencyLte;
  /**
   * 币种 比较(contains)
   */
  private String purchaseCurrencyContains;
  /**
   * 币种 比较(notcontains)
   */
  private String purchaseCurrencyNotcontains;
  /**
   * 币种 比较(startswith)
   */
  private String purchaseCurrencyStartswith;
  /**
   * 币种 比较(endswith)
   */
  private String purchaseCurrencyEndswith;
  /**
   * 币种 比较(isnull)
   */
  private Boolean purchaseCurrencyIsnull;
  /**
   * 币种 比较(isnotnull)
   */
  private Boolean purchaseCurrencyIsnotnull;

  /**
   * 币种(精确搜索)
   */
  private List<String> purchaseCurrencyInList;

  /**
   * 采购员
   */
  private Long buyerUid;

  /**
   * 采购员 比较(eq)
   */
  private Long buyerUidEq;
  /**
   * 采购员 比较(neq)
   */
  private Long buyerUidNeq;
  /**
   * 采购员 比较(gt)
   */
  private Long buyerUidGt;
  /**
   * 采购员 比较(gte)
   */
  private Long buyerUidGte;
  /**
   * 采购员 比较(lt)
   */
  private Long buyerUidLt;
  /**
   * 采购员 比较(lte)
   */
  private Long buyerUidLte;
  /**
   * 采购员 比较(contains)
   */
  private Long buyerUidContains;
  /**
   * 采购员 比较(notcontains)
   */
  private Long buyerUidNotcontains;
  /**
   * 采购员 比较(startswith)
   */
  private Long buyerUidStartswith;
  /**
   * 采购员 比较(endswith)
   */
  private Long buyerUidEndswith;
  /**
   * 采购员 比较(isnull)
   */
  private Boolean buyerUidIsnull;
  /**
   * 采购员 比较(isnotnull)
   */
  private Boolean buyerUidIsnotnull;
  /**
   * 采购员的显示用户名 比较(eq)
   */
  private String buyerUidNameEq;
  /**
   * 采购员的显示用户名 比较(neq)
   */
  private String buyerUidNameNeq;
  /**
   * 采购员的显示用户名 比较(gt)
   */
  private String buyerUidNameGt;
  /**
   * 采购员的显示用户名 比较(gte)
   */
  private String buyerUidNameGte;
  /**
   * 采购员的显示用户名 比较(lt)
   */
  private String buyerUidNameLt;
  /**
   * 采购员的显示用户名 比较(lte)
   */
  private String buyerUidNameLte;
  /**
   * 采购员的显示用户名 比较(contains)
   */
  private String buyerUidNameContains;
  /**
   * 采购员的显示用户名 比较(notcontains)
   */
  private String buyerUidNameNotcontains;
  /**
   * 采购员的显示用户名 比较(startswith)
   */
  private String buyerUidNameStartswith;
  /**
   * 采购员的显示用户名 比较(endswith)
   */
  private String buyerUidNameEndswith;
  /**
   * 采购员的显示用户名 比较(isnull)
   */
  private Boolean buyerUidNameIsnull;
  /**
   * 采购员的显示用户名 比较(isnotnull)
   */
  private Boolean buyerUidNameIsnotnull;

  /**
   * 采购员(范围搜索)
   */
  private List<Long> buyerUidInList;

  /**
   * 退款方式
   */
  private String returnMethod;

  /**
   * 退款方式 比较(eq)
   */
  private String returnMethodEq;
  /**
   * 退款方式 比较(neq)
   */
  private String returnMethodNeq;
  /**
   * 退款方式 比较(gt)
   */
  private String returnMethodGt;
  /**
   * 退款方式 比较(gte)
   */
  private String returnMethodGte;
  /**
   * 退款方式 比较(lt)
   */
  private String returnMethodLt;
  /**
   * 退款方式 比较(lte)
   */
  private String returnMethodLte;
  /**
   * 退款方式 比较(contains)
   */
  private String returnMethodContains;
  /**
   * 退款方式 比较(notcontains)
   */
  private String returnMethodNotcontains;
  /**
   * 退款方式 比较(startswith)
   */
  private String returnMethodStartswith;
  /**
   * 退款方式 比较(endswith)
   */
  private String returnMethodEndswith;
  /**
   * 退款方式 比较(isnull)
   */
  private Boolean returnMethodIsnull;
  /**
   * 退款方式 比较(isnotnull)
   */
  private Boolean returnMethodIsnotnull;

  /**
   * 退款方式(精确搜索)
   */
  private List<String> returnMethodInList;

  /**
   * 退货运费
   */
  private java.math.BigDecimal shippingPrice;

  /**
   * 最小退货运费
   */
  private java.math.BigDecimal shippingPriceMin;

  /**
   * 最大退货运费
   */
  private java.math.BigDecimal shippingPriceMax;

  /**
   * 退货运费 比较(eq)
   */
  private java.math.BigDecimal shippingPriceEq;
  /**
   * 退货运费 比较(neq)
   */
  private java.math.BigDecimal shippingPriceNeq;
  /**
   * 退货运费 比较(gt)
   */
  private java.math.BigDecimal shippingPriceGt;
  /**
   * 退货运费 比较(gte)
   */
  private java.math.BigDecimal shippingPriceGte;
  /**
   * 退货运费 比较(lt)
   */
  private java.math.BigDecimal shippingPriceLt;
  /**
   * 退货运费 比较(lte)
   */
  private java.math.BigDecimal shippingPriceLte;
  /**
   * 退货运费 比较(contains)
   */
  private java.math.BigDecimal shippingPriceContains;
  /**
   * 退货运费 比较(notcontains)
   */
  private java.math.BigDecimal shippingPriceNotcontains;
  /**
   * 退货运费 比较(startswith)
   */
  private java.math.BigDecimal shippingPriceStartswith;
  /**
   * 退货运费 比较(endswith)
   */
  private java.math.BigDecimal shippingPriceEndswith;
  /**
   * 退货运费 比较(isnull)
   */
  private Boolean shippingPriceIsnull;
  /**
   * 退货运费 比较(isnotnull)
   */
  private Boolean shippingPriceIsnotnull;

  /**
   * 其他费用
   */
  private java.math.BigDecimal otherFee;

  /**
   * 最小其他费用
   */
  private java.math.BigDecimal otherFeeMin;

  /**
   * 最大其他费用
   */
  private java.math.BigDecimal otherFeeMax;

  /**
   * 其他费用 比较(eq)
   */
  private java.math.BigDecimal otherFeeEq;
  /**
   * 其他费用 比较(neq)
   */
  private java.math.BigDecimal otherFeeNeq;
  /**
   * 其他费用 比较(gt)
   */
  private java.math.BigDecimal otherFeeGt;
  /**
   * 其他费用 比较(gte)
   */
  private java.math.BigDecimal otherFeeGte;
  /**
   * 其他费用 比较(lt)
   */
  private java.math.BigDecimal otherFeeLt;
  /**
   * 其他费用 比较(lte)
   */
  private java.math.BigDecimal otherFeeLte;
  /**
   * 其他费用 比较(contains)
   */
  private java.math.BigDecimal otherFeeContains;
  /**
   * 其他费用 比较(notcontains)
   */
  private java.math.BigDecimal otherFeeNotcontains;
  /**
   * 其他费用 比较(startswith)
   */
  private java.math.BigDecimal otherFeeStartswith;
  /**
   * 其他费用 比较(endswith)
   */
  private java.math.BigDecimal otherFeeEndswith;
  /**
   * 其他费用 比较(isnull)
   */
  private Boolean otherFeeIsnull;
  /**
   * 其他费用 比较(isnotnull)
   */
  private Boolean otherFeeIsnotnull;

  /**
   * 最早退货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date applicationDateStart;

  /**
   * 最晚退货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date applicationDateEnd;

  /**
   * 退货时间 比较(eq)
   */
  private Date applicationDateEq;
  /**
   * 退货时间 比较(neq)
   */
  private Date applicationDateNeq;
  /**
   * 退货时间 比较(gt)
   */
  private Date applicationDateGt;
  /**
   * 退货时间 比较(gte)
   */
  private Date applicationDateGte;
  /**
   * 退货时间 比较(lt)
   */
  private Date applicationDateLt;
  /**
   * 退货时间 比较(lte)
   */
  private Date applicationDateLte;
  /**
   * 退货时间 比较(contains)
   */
  private Date applicationDateContains;
  /**
   * 退货时间 比较(notcontains)
   */
  private Date applicationDateNotcontains;
  /**
   * 退货时间 比较(startswith)
   */
  private Date applicationDateStartswith;
  /**
   * 退货时间 比较(endswith)
   */
  private Date applicationDateEndswith;
  /**
   * 退货时间 比较(isnull)
   */
  private Boolean applicationDateIsnull;
  /**
   * 退货时间 比较(isnotnull)
   */
  private Boolean applicationDateIsnotnull;

  /**
   * 退货原因(模糊搜索)
   */
  private String returnReason;

  /**
   * 退货原因 比较(eq)
   */
  private String returnReasonEq;
  /**
   * 退货原因 比较(neq)
   */
  private String returnReasonNeq;
  /**
   * 退货原因 比较(gt)
   */
  private String returnReasonGt;
  /**
   * 退货原因 比较(gte)
   */
  private String returnReasonGte;
  /**
   * 退货原因 比较(lt)
   */
  private String returnReasonLt;
  /**
   * 退货原因 比较(lte)
   */
  private String returnReasonLte;
  /**
   * 退货原因 比较(contains)
   */
  private String returnReasonContains;
  /**
   * 退货原因 比较(notcontains)
   */
  private String returnReasonNotcontains;
  /**
   * 退货原因 比较(startswith)
   */
  private String returnReasonStartswith;
  /**
   * 退货原因 比较(endswith)
   */
  private String returnReasonEndswith;
  /**
   * 退货原因 比较(isnull)
   */
  private Boolean returnReasonIsnull;
  /**
   * 退货原因 比较(isnotnull)
   */
  private Boolean returnReasonIsnotnull;

  /**
   * 退货原因(精确搜索)
   */
  private List<String> returnReasonInList;

  /**
   * 是否有 附件
   */
  private Boolean file;

  /**
   * 申请部门
   */
  private Long dept;

  /**
   * 申请部门 比较(eq)
   */
  private Long deptEq;
  /**
   * 申请部门 比较(neq)
   */
  private Long deptNeq;
  /**
   * 申请部门 比较(gt)
   */
  private Long deptGt;
  /**
   * 申请部门 比较(gte)
   */
  private Long deptGte;
  /**
   * 申请部门 比较(lt)
   */
  private Long deptLt;
  /**
   * 申请部门 比较(lte)
   */
  private Long deptLte;
  /**
   * 申请部门 比较(contains)
   */
  private Long deptContains;
  /**
   * 申请部门 比较(notcontains)
   */
  private Long deptNotcontains;
  /**
   * 申请部门 比较(startswith)
   */
  private Long deptStartswith;
  /**
   * 申请部门 比较(endswith)
   */
  private Long deptEndswith;
  /**
   * 申请部门 比较(isnull)
   */
  private Boolean deptIsnull;
  /**
   * 申请部门 比较(isnotnull)
   */
  private Boolean deptIsnotnull;
  /**
   * 申请部门的部门名称 比较(eq)
   */
  private String deptNameEq;
  /**
   * 申请部门的部门名称 比较(neq)
   */
  private String deptNameNeq;
  /**
   * 申请部门的部门名称 比较(gt)
   */
  private String deptNameGt;
  /**
   * 申请部门的部门名称 比较(gte)
   */
  private String deptNameGte;
  /**
   * 申请部门的部门名称 比较(lt)
   */
  private String deptNameLt;
  /**
   * 申请部门的部门名称 比较(lte)
   */
  private String deptNameLte;
  /**
   * 申请部门的部门名称 比较(contains)
   */
  private String deptNameContains;
  /**
   * 申请部门的部门名称 比较(notcontains)
   */
  private String deptNameNotcontains;
  /**
   * 申请部门的部门名称 比较(startswith)
   */
  private String deptNameStartswith;
  /**
   * 申请部门的部门名称 比较(endswith)
   */
  private String deptNameEndswith;
  /**
   * 申请部门的部门名称 比较(isnull)
   */
  private Boolean deptNameIsnull;
  /**
   * 申请部门的部门名称 比较(isnotnull)
   */
  private Boolean deptNameIsnotnull;

  /**
   * 申请部门(范围搜索)
   */
  private List<Long> deptInList;

  /**
   * 状态
   */
  private String status;

  /**
   * 状态 比较(eq)
   */
  private String statusEq;
  /**
   * 状态 比较(neq)
   */
  private String statusNeq;
  /**
   * 状态 比较(gt)
   */
  private String statusGt;
  /**
   * 状态 比较(gte)
   */
  private String statusGte;
  /**
   * 状态 比较(lt)
   */
  private String statusLt;
  /**
   * 状态 比较(lte)
   */
  private String statusLte;
  /**
   * 状态 比较(contains)
   */
  private String statusContains;
  /**
   * 状态 比较(notcontains)
   */
  private String statusNotcontains;
  /**
   * 状态 比较(startswith)
   */
  private String statusStartswith;
  /**
   * 状态 比较(endswith)
   */
  private String statusEndswith;
  /**
   * 状态 比较(isnull)
   */
  private Boolean statusIsnull;
  /**
   * 状态 比较(isnotnull)
   */
  private Boolean statusIsnotnull;

  /**
   * 状态(精确搜索)
   */
  private List<String> statusInList;

  /**
   * 备注(模糊搜索)
   */
  private String remark;

  /**
   * 备注 比较(eq)
   */
  private String remarkEq;
  /**
   * 备注 比较(neq)
   */
  private String remarkNeq;
  /**
   * 备注 比较(gt)
   */
  private String remarkGt;
  /**
   * 备注 比较(gte)
   */
  private String remarkGte;
  /**
   * 备注 比较(lt)
   */
  private String remarkLt;
  /**
   * 备注 比较(lte)
   */
  private String remarkLte;
  /**
   * 备注 比较(contains)
   */
  private String remarkContains;
  /**
   * 备注 比较(notcontains)
   */
  private String remarkNotcontains;
  /**
   * 备注 比较(startswith)
   */
  private String remarkStartswith;
  /**
   * 备注 比较(endswith)
   */
  private String remarkEndswith;
  /**
   * 备注 比较(isnull)
   */
  private Boolean remarkIsnull;
  /**
   * 备注 比较(isnotnull)
   */
  private Boolean remarkIsnotnull;

  /**
   * 备注(精确搜索)
   */
  private List<String> remarkInList;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 标签(模糊搜索)
   */
  private String label;

  /**
   * 标签 比较(eq)
   */
  private String labelEq;
  /**
   * 标签 比较(neq)
   */
  private String labelNeq;
  /**
   * 标签 比较(gt)
   */
  private String labelGt;
  /**
   * 标签 比较(gte)
   */
  private String labelGte;
  /**
   * 标签 比较(lt)
   */
  private String labelLt;
  /**
   * 标签 比较(lte)
   */
  private String labelLte;
  /**
   * 标签 比较(contains)
   */
  private String labelContains;
  /**
   * 标签 比较(notcontains)
   */
  private String labelNotcontains;
  /**
   * 标签 比较(startswith)
   */
  private String labelStartswith;
  /**
   * 标签 比较(endswith)
   */
  private String labelEndswith;
  /**
   * 标签 比较(isnull)
   */
  private Boolean labelIsnull;
  /**
   * 标签 比较(isnotnull)
   */
  private Boolean labelIsnotnull;

  /**
   * 标签(精确搜索)
   */
  private List<String> labelInList;

  /**
   * 店铺
   */
  private Long sid;

  /**
   * 店铺 比较(eq)
   */
  private Long sidEq;
  /**
   * 店铺 比较(neq)
   */
  private Long sidNeq;
  /**
   * 店铺 比较(gt)
   */
  private Long sidGt;
  /**
   * 店铺 比较(gte)
   */
  private Long sidGte;
  /**
   * 店铺 比较(lt)
   */
  private Long sidLt;
  /**
   * 店铺 比较(lte)
   */
  private Long sidLte;
  /**
   * 店铺 比较(contains)
   */
  private Long sidContains;
  /**
   * 店铺 比较(notcontains)
   */
  private Long sidNotcontains;
  /**
   * 店铺 比较(startswith)
   */
  private Long sidStartswith;
  /**
   * 店铺 比较(endswith)
   */
  private Long sidEndswith;
  /**
   * 店铺 比较(isnull)
   */
  private Boolean sidIsnull;
  /**
   * 店铺 比较(isnotnull)
   */
  private Boolean sidIsnotnull;
  /**
   * 店铺的名称 比较(eq)
   */
  private String sidShopNameEq;
  /**
   * 店铺的名称 比较(neq)
   */
  private String sidShopNameNeq;
  /**
   * 店铺的名称 比较(gt)
   */
  private String sidShopNameGt;
  /**
   * 店铺的名称 比较(gte)
   */
  private String sidShopNameGte;
  /**
   * 店铺的名称 比较(lt)
   */
  private String sidShopNameLt;
  /**
   * 店铺的名称 比较(lte)
   */
  private String sidShopNameLte;
  /**
   * 店铺的名称 比较(contains)
   */
  private String sidShopNameContains;
  /**
   * 店铺的名称 比较(notcontains)
   */
  private String sidShopNameNotcontains;
  /**
   * 店铺的名称 比较(startswith)
   */
  private String sidShopNameStartswith;
  /**
   * 店铺的名称 比较(endswith)
   */
  private String sidShopNameEndswith;
  /**
   * 店铺的名称 比较(isnull)
   */
  private Boolean sidShopNameIsnull;
  /**
   * 店铺的名称 比较(isnotnull)
   */
  private Boolean sidShopNameIsnotnull;

  /**
   * 店铺(范围搜索)
   */
  private List<Long> sidInList;

  /**
   * MSKU/FNSKU(模糊搜索)
   */
  private String msku;

  /**
   * MSKU/FNSKU 比较(eq)
   */
  private String mskuEq;
  /**
   * MSKU/FNSKU 比较(neq)
   */
  private String mskuNeq;
  /**
   * MSKU/FNSKU 比较(gt)
   */
  private String mskuGt;
  /**
   * MSKU/FNSKU 比较(gte)
   */
  private String mskuGte;
  /**
   * MSKU/FNSKU 比较(lt)
   */
  private String mskuLt;
  /**
   * MSKU/FNSKU 比较(lte)
   */
  private String mskuLte;
  /**
   * MSKU/FNSKU 比较(contains)
   */
  private String mskuContains;
  /**
   * MSKU/FNSKU 比较(notcontains)
   */
  private String mskuNotcontains;
  /**
   * MSKU/FNSKU 比较(startswith)
   */
  private String mskuStartswith;
  /**
   * MSKU/FNSKU 比较(endswith)
   */
  private String mskuEndswith;
  /**
   * MSKU/FNSKU 比较(isnull)
   */
  private Boolean mskuIsnull;
  /**
   * MSKU/FNSKU 比较(isnotnull)
   */
  private Boolean mskuIsnotnull;

  /**
   * MSKU/FNSKU(精确搜索)
   */
  private List<String> mskuInList;

  /**
   * 可用品退货量
   */
  private Integer quantityAvailble;

  /**
   * 最小可用品退货量
   */
  private Integer quantityAvailbleMin;

  /**
   * 最大可用品退货量
   */
  private Integer quantityAvailbleMax;

  /**
   * 可用品退货量 比较(eq)
   */
  private Integer quantityAvailbleEq;
  /**
   * 可用品退货量 比较(neq)
   */
  private Integer quantityAvailbleNeq;
  /**
   * 可用品退货量 比较(gt)
   */
  private Integer quantityAvailbleGt;
  /**
   * 可用品退货量 比较(gte)
   */
  private Integer quantityAvailbleGte;
  /**
   * 可用品退货量 比较(lt)
   */
  private Integer quantityAvailbleLt;
  /**
   * 可用品退货量 比较(lte)
   */
  private Integer quantityAvailbleLte;
  /**
   * 可用品退货量 比较(contains)
   */
  private Integer quantityAvailbleContains;
  /**
   * 可用品退货量 比较(notcontains)
   */
  private Integer quantityAvailbleNotcontains;
  /**
   * 可用品退货量 比较(startswith)
   */
  private Integer quantityAvailbleStartswith;
  /**
   * 可用品退货量 比较(endswith)
   */
  private Integer quantityAvailbleEndswith;
  /**
   * 可用品退货量 比较(isnull)
   */
  private Boolean quantityAvailbleIsnull;
  /**
   * 可用品退货量 比较(isnotnull)
   */
  private Boolean quantityAvailbleIsnotnull;

  /**
   * 备注(模糊搜索)
   */
  private String remarks;

  /**
   * 备注 比较(eq)
   */
  private String remarksEq;
  /**
   * 备注 比较(neq)
   */
  private String remarksNeq;
  /**
   * 备注 比较(gt)
   */
  private String remarksGt;
  /**
   * 备注 比较(gte)
   */
  private String remarksGte;
  /**
   * 备注 比较(lt)
   */
  private String remarksLt;
  /**
   * 备注 比较(lte)
   */
  private String remarksLte;
  /**
   * 备注 比较(contains)
   */
  private String remarksContains;
  /**
   * 备注 比较(notcontains)
   */
  private String remarksNotcontains;
  /**
   * 备注 比较(startswith)
   */
  private String remarksStartswith;
  /**
   * 备注 比较(endswith)
   */
  private String remarksEndswith;
  /**
   * 备注 比较(isnull)
   */
  private Boolean remarksIsnull;
  /**
   * 备注 比较(isnotnull)
   */
  private Boolean remarksIsnotnull;

  /**
   * 备注(精确搜索)
   */
  private List<String> remarksInList;

  /**
   * 次品退货量
   */
  private Integer quantityUnavailble;

  /**
   * 最小次品退货量
   */
  private Integer quantityUnavailbleMin;

  /**
   * 最大次品退货量
   */
  private Integer quantityUnavailbleMax;

  /**
   * 次品退货量 比较(eq)
   */
  private Integer quantityUnavailbleEq;
  /**
   * 次品退货量 比较(neq)
   */
  private Integer quantityUnavailbleNeq;
  /**
   * 次品退货量 比较(gt)
   */
  private Integer quantityUnavailbleGt;
  /**
   * 次品退货量 比较(gte)
   */
  private Integer quantityUnavailbleGte;
  /**
   * 次品退货量 比较(lt)
   */
  private Integer quantityUnavailbleLt;
  /**
   * 次品退货量 比较(lte)
   */
  private Integer quantityUnavailbleLte;
  /**
   * 次品退货量 比较(contains)
   */
  private Integer quantityUnavailbleContains;
  /**
   * 次品退货量 比较(notcontains)
   */
  private Integer quantityUnavailbleNotcontains;
  /**
   * 次品退货量 比较(startswith)
   */
  private Integer quantityUnavailbleStartswith;
  /**
   * 次品退货量 比较(endswith)
   */
  private Integer quantityUnavailbleEndswith;
  /**
   * 次品退货量 比较(isnull)
   */
  private Boolean quantityUnavailbleIsnull;
  /**
   * 次品退货量 比较(isnotnull)
   */
  private Boolean quantityUnavailbleIsnotnull;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
